home *** CD-ROM | disk | FTP | other *** search
/ Scene Storm / Scene Storm - Volume 1.iso / coding / tools / gcc / gcc270_src.lha / gcc-2.7.0-amiga / gcc.info-12 < prev    next >
Encoding:
GNU Info File  |  1995-06-16  |  49.1 KB  |  1,102 lines

  1. This is Info file gcc.info, produced by Makeinfo-1.55 from the input
  2. file gcc.texi.
  3.  
  4.    This file documents the use and the internals of the GNU compiler.
  5.  
  6.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  7. Boston, MA 02111-1307 USA
  8.  
  9.    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software
  10. Foundation, Inc.
  11.  
  12.    Permission is granted to make and distribute verbatim copies of this
  13. manual provided the copyright notice and this permission notice are
  14. preserved on all copies.
  15.  
  16.    Permission is granted to copy and distribute modified versions of
  17. this manual under the conditions for verbatim copying, provided also
  18. that the sections entitled "GNU General Public License," "Funding for
  19. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  20. included exactly as in the original, and provided that the entire
  21. resulting derived work is distributed under the terms of a permission
  22. notice identical to this one.
  23.  
  24.    Permission is granted to copy and distribute translations of this
  25. manual into another language, under the above conditions for modified
  26. versions, except that the sections entitled "GNU General Public
  27. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  28. `Look And Feel'", and this permission notice, may be included in
  29. translations approved by the Free Software Foundation instead of in the
  30. original English.
  31.  
  32. 
  33. File: gcc.info,  Node: Non-bugs,  Next: Warnings and Errors,  Prev: Protoize Caveats,  Up: Trouble
  34.  
  35. Certain Changes We Don't Want to Make
  36. =====================================
  37.  
  38.    This section lists changes that people frequently request, but which
  39. we do not make because we think GNU CC is better without them.
  40.  
  41.    * Checking the number and type of arguments to a function which has
  42.      an old-fashioned definition and no prototype.
  43.  
  44.      Such a feature would work only occasionally--only for calls that
  45.      appear in the same file as the called function, following the
  46.      definition.  The only way to check all calls reliably is to add a
  47.      prototype for the function.  But adding a prototype eliminates the
  48.      motivation for this feature.  So the feature is not worthwhile.
  49.  
  50.    * Warning about using an expression whose type is signed as a shift
  51.      count.
  52.  
  53.      Shift count operands are probably signed more often than unsigned.
  54.      Warning about this would cause far more annoyance than good.
  55.  
  56.    * Warning about assigning a signed value to an unsigned variable.
  57.  
  58.      Such assignments must be very common; warning about them would
  59.      cause more annoyance than good.
  60.  
  61.    * Warning about unreachable code.
  62.  
  63.      It's very common to have unreachable code in machine-generated
  64.      programs.  For example, this happens normally in some files of GNU
  65.      C itself.
  66.  
  67.    * Warning when a non-void function value is ignored.
  68.  
  69.      Coming as I do from a Lisp background, I balk at the idea that
  70.      there is something dangerous about discarding a value.  There are
  71.      functions that return values which some callers may find useful;
  72.      it makes no sense to clutter the program with a cast to `void'
  73.      whenever the value isn't useful.
  74.  
  75.    * Assuming (for optimization) that the address of an external symbol
  76.      is never zero.
  77.  
  78.      This assumption is false on certain systems when `#pragma weak' is
  79.      used.
  80.  
  81.    * Making `-fshort-enums' the default.
  82.  
  83.      This would cause storage layout to be incompatible with most other
  84.      C compilers.  And it doesn't seem very important, given that you
  85.      can get the same result in other ways.  The case where it matters
  86.      most is when the enumeration-valued object is inside a structure,
  87.      and in that case you can specify a field width explicitly.
  88.  
  89.    * Making bitfields unsigned by default on particular machines where
  90.      "the ABI standard" says to do so.
  91.  
  92.      The ANSI C standard leaves it up to the implementation whether a
  93.      bitfield declared plain `int' is signed or not.  This in effect
  94.      creates two alternative dialects of C.
  95.  
  96.      The GNU C compiler supports both dialects; you can specify the
  97.      signed dialect with `-fsigned-bitfields' and the unsigned dialect
  98.      with `-funsigned-bitfields'.  However, this leaves open the
  99.      question of which dialect to use by default.
  100.  
  101.      Currently, the preferred dialect makes plain bitfields signed,
  102.      because this is simplest.  Since `int' is the same as `signed int'
  103.      in every other context, it is cleanest for them to be the same in
  104.      bitfields as well.
  105.  
  106.      Some computer manufacturers have published Application Binary
  107.      Interface standards which specify that plain bitfields should be
  108.      unsigned.  It is a mistake, however, to say anything about this
  109.      issue in an ABI.  This is because the handling of plain bitfields
  110.      distinguishes two dialects of C.  Both dialects are meaningful on
  111.      every type of machine.  Whether a particular object file was
  112.      compiled using signed bitfields or unsigned is of no concern to
  113.      other object files, even if they access the same bitfields in the
  114.      same data structures.
  115.  
  116.      A given program is written in one or the other of these two
  117.      dialects.  The program stands a chance to work on most any machine
  118.      if it is compiled with the proper dialect.  It is unlikely to work
  119.      at all if compiled with the wrong dialect.
  120.  
  121.      Many users appreciate the GNU C compiler because it provides an
  122.      environment that is uniform across machines.  These users would be
  123.      inconvenienced if the compiler treated plain bitfields differently
  124.      on certain machines.
  125.  
  126.      Occasionally users write programs intended only for a particular
  127.      machine type.  On these occasions, the users would benefit if the
  128.      GNU C compiler were to support by default the same dialect as the
  129.      other compilers on that machine.  But such applications are rare.
  130.      And users writing a program to run on more than one type of
  131.      machine cannot possibly benefit from this kind of compatibility.
  132.  
  133.      This is why GNU CC does and will treat plain bitfields in the same
  134.      fashion on all types of machines (by default).
  135.  
  136.      There are some arguments for making bitfields unsigned by default
  137.      on all machines.  If, for example, this becomes a universal de
  138.      facto standard, it would make sense for GNU CC to go along with
  139.      it.  This is something to be considered in the future.
  140.  
  141.      (Of course, users strongly concerned about portability should
  142.      indicate explicitly in each bitfield whether it is signed or not.
  143.      In this way, they write programs which have the same meaning in
  144.      both C dialects.)
  145.  
  146.    * Undefining `__STDC__' when `-ansi' is not used.
  147.  
  148.      Currently, GNU CC defines `__STDC__' as long as you don't use
  149.      `-traditional'.  This provides good results in practice.
  150.  
  151.      Programmers normally use conditionals on `__STDC__' to ask whether
  152.      it is safe to use certain features of ANSI C, such as function
  153.      prototypes or ANSI token concatenation.  Since plain `gcc' supports
  154.      all the features of ANSI C, the correct answer to these questions
  155.      is "yes".
  156.  
  157.      Some users try to use `__STDC__' to check for the availability of
  158.      certain library facilities.  This is actually incorrect usage in
  159.      an ANSI C program, because the ANSI C standard says that a
  160.      conforming freestanding implementation should define `__STDC__'
  161.      even though it does not have the library facilities.  `gcc -ansi
  162.      -pedantic' is a conforming freestanding implementation, and it is
  163.      therefore required to define `__STDC__', even though it does not
  164.      come with an ANSI C library.
  165.  
  166.      Sometimes people say that defining `__STDC__' in a compiler that
  167.      does not completely conform to the ANSI C standard somehow
  168.      violates the standard.  This is illogical.  The standard is a
  169.      standard for compilers that claim to support ANSI C, such as `gcc
  170.      -ansi'--not for other compilers such as plain `gcc'.  Whatever the
  171.      ANSI C standard says is relevant to the design of plain `gcc'
  172.      without `-ansi' only for pragmatic reasons, not as a requirement.
  173.  
  174.    * Undefining `__STDC__' in C++.
  175.  
  176.      Programs written to compile with C++-to-C translators get the
  177.      value of `__STDC__' that goes with the C compiler that is
  178.      subsequently used.  These programs must test `__STDC__' to
  179.      determine what kind of C preprocessor that compiler uses: whether
  180.      they should concatenate tokens in the ANSI C fashion or in the
  181.      traditional fashion.
  182.  
  183.      These programs work properly with GNU C++ if `__STDC__' is defined.
  184.      They would not work otherwise.
  185.  
  186.      In addition, many header files are written to provide prototypes
  187.      in ANSI C but not in traditional C.  Many of these header files
  188.      can work without change in C++ provided `__STDC__' is defined.  If
  189.      `__STDC__' is not defined, they will all fail, and will all need
  190.      to be changed to test explicitly for C++ as well.
  191.  
  192.    * Deleting "empty" loops.
  193.  
  194.      GNU CC does not delete "empty" loops because the most likely reason
  195.      you would put one in a program is to have a delay.  Deleting them
  196.      will not make real programs run any faster, so it would be
  197.      pointless.
  198.  
  199.      It would be different if optimization of a nonempty loop could
  200.      produce an empty one.  But this generally can't happen.
  201.  
  202.    * Making side effects happen in the same order as in some other
  203.      compiler.
  204.  
  205.      It is never safe to depend on the order of evaluation of side
  206.      effects.  For example, a function call like this may very well
  207.      behave differently from one compiler to another:
  208.  
  209.           void func (int, int);
  210.           
  211.           int i = 2;
  212.           func (i++, i++);
  213.  
  214.      There is no guarantee (in either the C or the C++ standard language
  215.      definitions) that the increments will be evaluated in any
  216.      particular order.  Either increment might happen first.  `func'
  217.      might get the arguments `2, 3', or it might get `3, 2', or even
  218.      `2, 2'.
  219.  
  220.    * Not allowing structures with volatile fields in registers.
  221.  
  222.      Strictly speaking, there is no prohibition in the ANSI C standard
  223.      against allowing structures with volatile fields in registers, but
  224.      it does not seem to make any sense and is probably not what you
  225.      wanted to do.  So the compiler will give an error message in this
  226.      case.
  227.  
  228. 
  229. File: gcc.info,  Node: Warnings and Errors,  Prev: Non-bugs,  Up: Trouble
  230.  
  231. Warning Messages and Error Messages
  232. ===================================
  233.  
  234.    The GNU compiler can produce two kinds of diagnostics: errors and
  235. warnings.  Each kind has a different purpose:
  236.  
  237.      *Errors* report problems that make it impossible to compile your
  238.      program.  GNU CC reports errors with the source file name and line
  239.      number where the problem is apparent.
  240.  
  241.      *Warnings* report other unusual conditions in your code that *may*
  242.      indicate a problem, although compilation can (and does) proceed.
  243.      Warning messages also report the source file name and line number,
  244.      but include the text `warning:' to distinguish them from error
  245.      messages.
  246.  
  247.    Warnings may indicate danger points where you should check to make
  248. sure that your program really does what you intend; or the use of
  249. obsolete features; or the use of nonstandard features of GNU C or C++.
  250. Many warnings are issued only if you ask for them, with one of the `-W'
  251. options (for instance, `-Wall' requests a variety of useful warnings).
  252.  
  253.    GNU CC always tries to compile your program if possible; it never
  254. gratuitously rejects a program whose meaning is clear merely because
  255. (for instance) it fails to conform to a standard.  In some cases,
  256. however, the C and C++ standards specify that certain extensions are
  257. forbidden, and a diagnostic *must* be issued by a conforming compiler.
  258. The `-pedantic' option tells GNU CC to issue warnings in such cases;
  259. `-pedantic-errors' says to make them errors instead.  This does not
  260. mean that *all* non-ANSI constructs get warnings or errors.
  261.  
  262.    *Note Options to Request or Suppress Warnings: Warning Options, for
  263. more detail on these and related command-line options.
  264.  
  265. 
  266. File: gcc.info,  Node: Bugs,  Next: Service,  Prev: Trouble,  Up: Top
  267.  
  268. Reporting Bugs
  269. **************
  270.  
  271.    Your bug reports play an essential role in making GNU CC reliable.
  272.  
  273.    When you encounter a problem, the first thing to do is to see if it
  274. is already known.  *Note Trouble::.  If it isn't known, then you should
  275. report the problem.
  276.  
  277.    Reporting a bug may help you by bringing a solution to your problem,
  278. or it may not.  (If it does not, look in the service directory; see
  279. *Note Service::.)  In any case, the principal function of a bug report
  280. is to help the entire community by making the next version of GNU CC
  281. work better.  Bug reports are your contribution to the maintenance of
  282. GNU CC.
  283.  
  284.    Since the maintainers are very overloaded, we cannot respond to every
  285. bug report.  However, if the bug has not been fixed, we are likely to
  286. send you a patch and ask you to tell us whether it works.
  287.  
  288.    In order for a bug report to serve its purpose, you must include the
  289. information that makes for fixing the bug.
  290.  
  291. * Menu:
  292.  
  293. * Criteria:  Bug Criteria.   Have you really found a bug?
  294. * Where: Bug Lists.         Where to send your bug report.
  295. * Reporting: Bug Reporting.  How to report a bug effectively.
  296. * Patches: Sending Patches.  How to send a patch for GNU CC.
  297. * Known: Trouble.            Known problems.
  298. * Help: Service.             Where to ask for help.
  299.  
  300. 
  301. File: gcc.info,  Node: Bug Criteria,  Next: Bug Lists,  Up: Bugs
  302.  
  303. Have You Found a Bug?
  304. =====================
  305.  
  306.    If you are not sure whether you have found a bug, here are some
  307. guidelines:
  308.  
  309.    * If the compiler gets a fatal signal, for any input whatever, that
  310.      is a compiler bug.  Reliable compilers never crash.
  311.  
  312.    * If the compiler produces invalid assembly code, for any input
  313.      whatever (except an `asm' statement), that is a compiler bug,
  314.      unless the compiler reports errors (not just warnings) which would
  315.      ordinarily prevent the assembler from being run.
  316.  
  317.    * If the compiler produces valid assembly code that does not
  318.      correctly execute the input source code, that is a compiler bug.
  319.  
  320.      However, you must double-check to make sure, because you may have
  321.      run into an incompatibility between GNU C and traditional C (*note
  322.      Incompatibilities::.).  These incompatibilities might be considered
  323.      bugs, but they are inescapable consequences of valuable features.
  324.  
  325.      Or you may have a program whose behavior is undefined, which
  326.      happened by chance to give the desired results with another C or
  327.      C++ compiler.
  328.  
  329.      For example, in many nonoptimizing compilers, you can write `x;'
  330.      at the end of a function instead of `return x;', with the same
  331.      results.  But the value of the function is undefined if `return'
  332.      is omitted; it is not a bug when GNU CC produces different results.
  333.  
  334.      Problems often result from expressions with two increment
  335.      operators, as in `f (*p++, *p++)'.  Your previous compiler might
  336.      have interpreted that expression the way you intended; GNU CC might
  337.      interpret it another way.  Neither compiler is wrong.  The bug is
  338.      in your code.
  339.  
  340.      After you have localized the error to a single source line, it
  341.      should be easy to check for these things.  If your program is
  342.      correct and well defined, you have found a compiler bug.
  343.  
  344.    * If the compiler produces an error message for valid input, that is
  345.      a compiler bug.
  346.  
  347.    * If the compiler does not produce an error message for invalid
  348.      input, that is a compiler bug.  However, you should note that your
  349.      idea of "invalid input" might be my idea of "an extension" or
  350.      "support for traditional practice".
  351.  
  352.    * If you are an experienced user of C or C++ compilers, your
  353.      suggestions for improvement of GNU CC or GNU C++ are welcome in
  354.      any case.
  355.  
  356. 
  357. File: gcc.info,  Node: Bug Lists,  Next: Bug Reporting,  Prev: Bug Criteria,  Up: Bugs
  358.  
  359. Where to Report Bugs
  360. ====================
  361.  
  362.    Send bug reports for GNU C to `bug-gcc@prep.ai.mit.edu'.
  363.  
  364.    Send bug reports for GNU C++ to `bug-g++@prep.ai.mit.edu'.  If your
  365. bug involves the C++ class library libg++, send mail to
  366. `bug-lib-g++@prep.ai.mit.edu'.  If you're not sure, you can send the
  367. bug report to both lists.
  368.  
  369.    *Do not send bug reports to `help-gcc@prep.ai.mit.edu' or to the
  370. newsgroup `gnu.gcc.help'.* Most users of GNU CC do not want to receive
  371. bug reports.  Those that do, have asked to be on `bug-gcc' and/or
  372. `bug-g++'.
  373.  
  374.    The mailing lists `bug-gcc' and `bug-g++' both have newsgroups which
  375. serve as repeaters: `gnu.gcc.bug' and `gnu.g++.bug'.  Each mailing list
  376. and its newsgroup carry exactly the same messages.
  377.  
  378.    Often people think of posting bug reports to the newsgroup instead of
  379. mailing them.  This appears to work, but it has one problem which can be
  380. crucial: a newsgroup posting does not contain a mail path back to the
  381. sender.  Thus, if maintainers need more information, they may be unable
  382. to reach you.  For this reason, you should always send bug reports by
  383. mail to the proper mailing list.
  384.  
  385.    As a last resort, send bug reports on paper to:
  386.  
  387.      GNU Compiler Bugs
  388.      Free Software Foundation
  389.      675 Mass Ave
  390.      Cambridge, MA 02139
  391.  
  392. 
  393. File: gcc.info,  Node: Bug Reporting,  Next: Sending Patches,  Prev: Bug Lists,  Up: Bugs
  394.  
  395. How to Report Bugs
  396. ==================
  397.  
  398.    The fundamental principle of reporting bugs usefully is this:
  399. *report all the facts*.  If you are not sure whether to state a fact or
  400. leave it out, state it!
  401.  
  402.    Often people omit facts because they think they know what causes the
  403. problem and they conclude that some details don't matter.  Thus, you
  404. might assume that the name of the variable you use in an example does
  405. not matter.  Well, probably it doesn't, but one cannot be sure.
  406. Perhaps the bug is a stray memory reference which happens to fetch from
  407. the location where that name is stored in memory; perhaps, if the name
  408. were different, the contents of that location would fool the compiler
  409. into doing the right thing despite the bug.  Play it safe and give a
  410. specific, complete example.  That is the easiest thing for you to do,
  411. and the most helpful.
  412.  
  413.    Keep in mind that the purpose of a bug report is to enable someone to
  414. fix the bug if it is not known.  It isn't very important what happens if
  415. the bug is already known.  Therefore, always write your bug reports on
  416. the assumption that the bug is not known.
  417.  
  418.    Sometimes people give a few sketchy facts and ask, "Does this ring a
  419. bell?"  This cannot help us fix a bug, so it is basically useless.  We
  420. respond by asking for enough details to enable us to investigate.  You
  421. might as well expedite matters by sending them to begin with.
  422.  
  423.    Try to make your bug report self-contained.  If we have to ask you
  424. for more information, it is best if you include all the previous
  425. information in your response, as well as the information that was
  426. missing.
  427.  
  428.    Please report each bug in a separate message.  This makes it easier
  429. for us to track which bugs have been fixed and to forward your bugs
  430. reports to the appropriate maintainer.
  431.  
  432.    Do not compress and encode any part of your bug report using programs
  433. such as `uuencode'.  If you do so it will slow down the processing of
  434. your bug.  If you must submit multiple large files, use `shar', which
  435. allows us to read your message without having to run any decompression
  436. programs.
  437.  
  438.    To enable someone to investigate the bug, you should include all
  439. these things:
  440.  
  441.    * The version of GNU CC.  You can get this by running it with the
  442.      `-v' option.
  443.  
  444.      Without this, we won't know whether there is any point in looking
  445.      for the bug in the current version of GNU CC.
  446.  
  447.    * A complete input file that will reproduce the bug.  If the bug is
  448.      in the C preprocessor, send a source file and any header files
  449.      that it requires.  If the bug is in the compiler proper (`cc1'),
  450.      run your source file through the C preprocessor by doing `gcc -E
  451.      SOURCEFILE > OUTFILE', then include the contents of OUTFILE in the
  452.      bug report.  (When you do this, use the same `-I', `-D' or `-U'
  453.      options that you used in actual compilation.)
  454.  
  455.      A single statement is not enough of an example.  In order to
  456.      compile it, it must be embedded in a complete file of compiler
  457.      input; and the bug might depend on the details of how this is done.
  458.  
  459.      Without a real example one can compile, all anyone can do about
  460.      your bug report is wish you luck.  It would be futile to try to
  461.      guess how to provoke the bug.  For example, bugs in register
  462.      allocation and reloading frequently depend on every little detail
  463.      of the function they happen in.
  464.  
  465.      Even if the input file that fails comes from a GNU program, you
  466.      should still send the complete test case.  Don't ask the GNU CC
  467.      maintainers to do the extra work of obtaining the program in
  468.      question--they are all overworked as it is.  Also, the problem may
  469.      depend on what is in the header files on your system; it is
  470.      unreliable for the GNU CC maintainers to try the problem with the
  471.      header files available to them.  By sending CPP output, you can
  472.      eliminate this source of uncertainty and save us a certain
  473.      percentage of wild goose chases.
  474.  
  475.    * The command arguments you gave GNU CC or GNU C++ to compile that
  476.      example and observe the bug.  For example, did you use `-O'?  To
  477.      guarantee you won't omit something important, list all the options.
  478.  
  479.      If we were to try to guess the arguments, we would probably guess
  480.      wrong and then we would not encounter the bug.
  481.  
  482.    * The type of machine you are using, and the operating system name
  483.      and version number.
  484.  
  485.    * The operands you gave to the `configure' command when you installed
  486.      the compiler.
  487.  
  488.    * A complete list of any modifications you have made to the compiler
  489.      source.  (We don't promise to investigate the bug unless it
  490.      happens in an unmodified compiler.  But if you've made
  491.      modifications and don't tell us, then you are sending us on a wild
  492.      goose chase.)
  493.  
  494.      Be precise about these changes.  A description in English is not
  495.      enough--send a context diff for them.
  496.  
  497.      Adding files of your own (such as a machine description for a
  498.      machine we don't support) is a modification of the compiler source.
  499.  
  500.    * Details of any other deviations from the standard procedure for
  501.      installing GNU CC.
  502.  
  503.    * A description of what behavior you observe that you believe is
  504.      incorrect.  For example, "The compiler gets a fatal signal," or,
  505.      "The assembler instruction at line 208 in the output is incorrect."
  506.  
  507.      Of course, if the bug is that the compiler gets a fatal signal,
  508.      then one can't miss it.  But if the bug is incorrect output, the
  509.      maintainer might not notice unless it is glaringly wrong.  None of
  510.      us has time to study all the assembler code from a 50-line C
  511.      program just on the chance that one instruction might be wrong.
  512.      We need *you* to do this part!
  513.  
  514.      Even if the problem you experience is a fatal signal, you should
  515.      still say so explicitly.  Suppose something strange is going on,
  516.      such as, your copy of the compiler is out of synch, or you have
  517.      encountered a bug in the C library on your system.  (This has
  518.      happened!)  Your copy might crash and the copy here would not.  If
  519.      you said to expect a crash, then when the compiler here fails to
  520.      crash, we would know that the bug was not happening.  If you don't
  521.      say to expect a crash, then we would not know whether the bug was
  522.      happening.  We would not be able to draw any conclusion from our
  523.      observations.
  524.  
  525.      If the problem is a diagnostic when compiling GNU CC with some
  526.      other compiler, say whether it is a warning or an error.
  527.  
  528.      Often the observed symptom is incorrect output when your program
  529.      is run.  Sad to say, this is not enough information unless the
  530.      program is short and simple.  None of us has time to study a large
  531.      program to figure out how it would work if compiled correctly,
  532.      much less which line of it was compiled wrong.  So you will have
  533.      to do that.  Tell us which source line it is, and what incorrect
  534.      result happens when that line is executed.  A person who
  535.      understands the program can find this as easily as finding a bug
  536.      in the program itself.
  537.  
  538.    * If you send examples of assembler code output from GNU CC or GNU
  539.      C++, please use `-g' when you make them.  The debugging information
  540.      includes source line numbers which are essential for correlating
  541.      the output with the input.
  542.  
  543.    * If you wish to mention something in the GNU CC source, refer to it
  544.      by context, not by line number.
  545.  
  546.      The line numbers in the development sources don't match those in
  547.      your sources.  Your line numbers would convey no useful
  548.      information to the maintainers.
  549.  
  550.    * Additional information from a debugger might enable someone to
  551.      find a problem on a machine which he does not have available.
  552.      However, you need to think when you collect this information if
  553.      you want it to have any chance of being useful.
  554.  
  555.      For example, many people send just a backtrace, but that is never
  556.      useful by itself.  A simple backtrace with arguments conveys little
  557.      about GNU CC because the compiler is largely data-driven; the same
  558.      functions are called over and over for different RTL insns, doing
  559.      different things depending on the details of the insn.
  560.  
  561.      Most of the arguments listed in the backtrace are useless because
  562.      they are pointers to RTL list structure.  The numeric values of the
  563.      pointers, which the debugger prints in the backtrace, have no
  564.      significance whatever; all that matters is the contents of the
  565.      objects they point to (and most of the contents are other such
  566.      pointers).
  567.  
  568.      In addition, most compiler passes consist of one or more loops that
  569.      scan the RTL insn sequence.  The most vital piece of information
  570.      about such a loop--which insn it has reached--is usually in a
  571.      local variable, not in an argument.
  572.  
  573.      What you need to provide in addition to a backtrace are the values
  574.      of the local variables for several stack frames up.  When a local
  575.      variable or an argument is an RTX, first print its value and then
  576.      use the GDB command `pr' to print the RTL expression that it points
  577.      to.  (If GDB doesn't run on your machine, use your debugger to call
  578.      the function `debug_rtx' with the RTX as an argument.)  In
  579.      general, whenever a variable is a pointer, its value is no use
  580.      without the data it points to.
  581.  
  582.    Here are some things that are not necessary:
  583.  
  584.    * A description of the envelope of the bug.
  585.  
  586.      Often people who encounter a bug spend a lot of time investigating
  587.      which changes to the input file will make the bug go away and which
  588.      changes will not affect it.
  589.  
  590.      This is often time consuming and not very useful, because the way
  591.      we will find the bug is by running a single example under the
  592.      debugger with breakpoints, not by pure deduction from a series of
  593.      examples.  You might as well save your time for something else.
  594.  
  595.      Of course, if you can find a simpler example to report *instead* of
  596.      the original one, that is a convenience.  Errors in the output
  597.      will be easier to spot, running under the debugger will take less
  598.      time, etc.  Most GNU CC bugs involve just one function, so the
  599.      most straightforward way to simplify an example is to delete all
  600.      the function definitions except the one where the bug occurs.
  601.      Those earlier in the file may be replaced by external declarations
  602.      if the crucial function depends on them.  (Exception: inline
  603.      functions may affect compilation of functions defined later in the
  604.      file.)
  605.  
  606.      However, simplification is not vital; if you don't want to do this,
  607.      report the bug anyway and send the entire test case you used.
  608.  
  609.    * In particular, some people insert conditionals `#ifdef BUG' around
  610.      a statement which, if removed, makes the bug not happen.  These
  611.      are just clutter; we won't pay any attention to them anyway.
  612.      Besides, you should send us cpp output, and that can't have
  613.      conditionals.
  614.  
  615.    * A patch for the bug.
  616.  
  617.      A patch for the bug is useful if it is a good one.  But don't omit
  618.      the necessary information, such as the test case, on the
  619.      assumption that a patch is all we need.  We might see problems
  620.      with your patch and decide to fix the problem another way, or we
  621.      might not understand it at all.
  622.  
  623.      Sometimes with a program as complicated as GNU CC it is very hard
  624.      to construct an example that will make the program follow a
  625.      certain path through the code.  If you don't send the example, we
  626.      won't be able to construct one, so we won't be able to verify that
  627.      the bug is fixed.
  628.  
  629.      And if we can't understand what bug you are trying to fix, or why
  630.      your patch should be an improvement, we won't install it.  A test
  631.      case will help us to understand.
  632.  
  633.      *Note Sending Patches::, for guidelines on how to make it easy for
  634.      us to understand and install your patches.
  635.  
  636.    * A guess about what the bug is or what it depends on.
  637.  
  638.      Such guesses are usually wrong.  Even I can't guess right about
  639.      such things without first using the debugger to find the facts.
  640.  
  641.    * A core dump file.
  642.  
  643.      We have no way of examining a core dump for your type of machine
  644.      unless we have an identical system--and if we do have one, we
  645.      should be able to reproduce the crash ourselves.
  646.  
  647. 
  648. File: gcc.info,  Node: Sending Patches,  Prev: Bug Reporting,  Up: Bugs
  649.  
  650. Sending Patches for GNU CC
  651. ==========================
  652.  
  653.    If you would like to write bug fixes or improvements for the GNU C
  654. compiler, that is very helpful.  Send suggested fixes to the bug report
  655. mailing list, `bug-gcc@prep.ai.mit.edu'.
  656.  
  657.    Please follow these guidelines so we can study your patches
  658. efficiently.  If you don't follow these guidelines, your information
  659. might still be useful, but using it will take extra work.  Maintaining
  660. GNU C is a lot of work in the best of circumstances, and we can't keep
  661. up unless you do your best to help.
  662.  
  663.    * Send an explanation with your changes of what problem they fix or
  664.      what improvement they bring about.  For a bug fix, just include a
  665.      copy of the bug report, and explain why the change fixes the bug.
  666.  
  667.      (Referring to a bug report is not as good as including it, because
  668.      then we will have to look it up, and we have probably already
  669.      deleted it if we've already fixed the bug.)
  670.  
  671.    * Always include a proper bug report for the problem you think you
  672.      have fixed.  We need to convince ourselves that the change is
  673.      right before installing it.  Even if it is right, we might have
  674.      trouble judging it if we don't have a way to reproduce the problem.
  675.  
  676.    * Include all the comments that are appropriate to help people
  677.      reading the source in the future understand why this change was
  678.      needed.
  679.  
  680.    * Don't mix together changes made for different reasons.  Send them
  681.      *individually*.
  682.  
  683.      If you make two changes for separate reasons, then we might not
  684.      want to install them both.  We might want to install just one.  If
  685.      you send them all jumbled together in a single set of diffs, we
  686.      have to do extra work to disentangle them--to figure out which
  687.      parts of the change serve which purpose.  If we don't have time
  688.      for this, we might have to ignore your changes entirely.
  689.  
  690.      If you send each change as soon as you have written it, with its
  691.      own explanation, then the two changes never get tangled up, and we
  692.      can consider each one properly without any extra work to
  693.      disentangle them.
  694.  
  695.      Ideally, each change you send should be impossible to subdivide
  696.      into parts that we might want to consider separately, because each
  697.      of its parts gets its motivation from the other parts.
  698.  
  699.    * Send each change as soon as that change is finished.  Sometimes
  700.      people think they are helping us by accumulating many changes to
  701.      send them all together.  As explained above, this is absolutely
  702.      the worst thing you could do.
  703.  
  704.      Since you should send each change separately, you might as well
  705.      send it right away.  That gives us the option of installing it
  706.      immediately if it is important.
  707.  
  708.    * Use `diff -c' to make your diffs.  Diffs without context are hard
  709.      for us to install reliably.  More than that, they make it hard for
  710.      us to study the diffs to decide whether we want to install them.
  711.      Unidiff format is better than contextless diffs, but not as easy
  712.      to read as `-c' format.
  713.  
  714.      If you have GNU diff, use `diff -cp', which shows the name of the
  715.      function that each change occurs in.
  716.  
  717.    * Write the change log entries for your changes.  We get lots of
  718.      changes, and we don't have time to do all the change log writing
  719.      ourselves.
  720.  
  721.      Read the `ChangeLog' file to see what sorts of information to put
  722.      in, and to learn the style that we use.  The purpose of the change
  723.      log is to show people where to find what was changed.  So you need
  724.      to be specific about what functions you changed; in large
  725.      functions, it's often helpful to indicate where within the
  726.      function the change was.
  727.  
  728.      On the other hand, once you have shown people where to find the
  729.      change, you need not explain its purpose.  Thus, if you add a new
  730.      function, all you need to say about it is that it is new.  If you
  731.      feel that the purpose needs explaining, it probably does--but the
  732.      explanation will be much more useful if you put it in comments in
  733.      the code.
  734.  
  735.      If you would like your name to appear in the header line for who
  736.      made the change, send us the header line.
  737.  
  738.    * When you write the fix, keep in mind that we can't install a
  739.      change that would break other systems.
  740.  
  741.      People often suggest fixing a problem by changing
  742.      machine-independent files such as `toplev.c' to do something
  743.      special that a particular system needs.  Sometimes it is totally
  744.      obvious that such changes would break GNU CC for almost all users.
  745.      We can't possibly make a change like that.  At best it might tell
  746.      us how to write another patch that would solve the problem
  747.      acceptably.
  748.  
  749.      Sometimes people send fixes that *might* be an improvement in
  750.      general--but it is hard to be sure of this.  It's hard to install
  751.      such changes because we have to study them very carefully.  Of
  752.      course, a good explanation of the reasoning by which you concluded
  753.      the change was correct can help convince us.
  754.  
  755.      The safest changes are changes to the configuration files for a
  756.      particular machine.  These are safe because they can't create new
  757.      bugs on other machines.
  758.  
  759.      Please help us keep up with the workload by designing the patch in
  760.      a form that is good to install.
  761.  
  762. 
  763. File: gcc.info,  Node: Service,  Next: VMS,  Prev: Bugs,  Up: Top
  764.  
  765. How To Get Help with GNU CC
  766. ***************************
  767.  
  768.    If you need help installing, using or changing GNU CC, there are two
  769. ways to find it:
  770.  
  771.    * Send a message to a suitable network mailing list.  First try
  772.      `bug-gcc@prep.ai.mit.edu', and if that brings no response, try
  773.      `help-gcc@prep.ai.mit.edu'.
  774.  
  775.    * Look in the service directory for someone who might help you for a
  776.      fee.  The service directory is found in the file named `SERVICE'
  777.      in the GNU CC distribution.
  778.  
  779. 
  780. File: gcc.info,  Node: VMS,  Next: Portability,  Prev: Service,  Up: Top
  781.  
  782. Using GNU CC on VMS
  783. *******************
  784.  
  785.    Here is how to use GNU CC on VMS.
  786.  
  787. * Menu:
  788.  
  789. * Include Files and VMS::  Where the preprocessor looks for the include files.
  790. * Global Declarations::    How to do globaldef, globalref and globalvalue with
  791.                            GNU CC.
  792. * VMS Misc::           Misc information.
  793.  
  794. 
  795. File: gcc.info,  Node: Include Files and VMS,  Next: Global Declarations,  Up: VMS
  796.  
  797. Include Files and VMS
  798. =====================
  799.  
  800.    Due to the differences between the filesystems of Unix and VMS, GNU
  801. CC attempts to translate file names in `#include' into names that VMS
  802. will understand.  The basic strategy is to prepend a prefix to the
  803. specification of the include file, convert the whole filename to a VMS
  804. filename, and then try to open the file.  GNU CC tries various prefixes
  805. one by one until one of them succeeds:
  806.  
  807.   1. The first prefix is the `GNU_CC_INCLUDE:' logical name: this is
  808.      where GNU C header files are traditionally stored.  If you wish to
  809.      store header files in non-standard locations, then you can assign
  810.      the logical `GNU_CC_INCLUDE' to be a search list, where each
  811.      element of the list is suitable for use with a rooted logical.
  812.  
  813.   2. The next prefix tried is `SYS$SYSROOT:[SYSLIB.]'.  This is where
  814.      VAX-C header files are traditionally stored.
  815.  
  816.   3. If the include file specification by itself is a valid VMS
  817.      filename, the preprocessor then uses this name with no prefix in
  818.      an attempt to open the include file.
  819.  
  820.   4. If the file specification is not a valid VMS filename (i.e. does
  821.      not contain a device or a directory specifier, and contains a `/'
  822.      character), the preprocessor tries to convert it from Unix syntax
  823.      to VMS syntax.
  824.  
  825.      Conversion works like this: the first directory name becomes a
  826.      device, and the rest of the directories are converted into
  827.      VMS-format directory names.  For example, the name `X11/foobar.h'
  828.      is translated to `X11:[000000]foobar.h' or `X11:foobar.h',
  829.      whichever one can be opened.  This strategy allows you to assign a
  830.      logical name to point to the actual location of the header files.
  831.  
  832.   5. If none of these strategies succeeds, the `#include' fails.
  833.  
  834.    Include directives of the form:
  835.  
  836.      #include foobar
  837.  
  838. are a common source of incompatibility between VAX-C and GNU CC.  VAX-C
  839. treats this much like a standard `#include <foobar.h>' directive.  That
  840. is incompatible with the ANSI C behavior implemented by GNU CC: to
  841. expand the name `foobar' as a macro.  Macro expansion should eventually
  842. yield one of the two standard formats for `#include':
  843.  
  844.      #include "FILE"
  845.      #include <FILE>
  846.  
  847.    If you have this problem, the best solution is to modify the source
  848. to convert the `#include' directives to one of the two standard forms.
  849. That will work with either compiler.  If you want a quick and dirty fix,
  850. define the file names as macros with the proper expansion, like this:
  851.  
  852.      #define stdio <stdio.h>
  853.  
  854. This will work, as long as the name doesn't conflict with anything else
  855. in the program.
  856.  
  857.    Another source of incompatibility is that VAX-C assumes that:
  858.  
  859.      #include "foobar"
  860.  
  861. is actually asking for the file `foobar.h'.  GNU CC does not make this
  862. assumption, and instead takes what you ask for literally; it tries to
  863. read the file `foobar'.  The best way to avoid this problem is to
  864. always specify the desired file extension in your include directives.
  865.  
  866.    GNU CC for VMS is distributed with a set of include files that is
  867. sufficient to compile most general purpose programs.  Even though the
  868. GNU CC distribution does not contain header files to define constants
  869. and structures for some VMS system-specific functions, there is no
  870. reason why you cannot use GNU CC with any of these functions.  You first
  871. may have to generate or create header files, either by using the public
  872. domain utility `UNSDL' (which can be found on a DECUS tape), or by
  873. extracting the relevant modules from one of the system macro libraries,
  874. and using an editor to construct a C header file.
  875.  
  876.    A `#include' file name cannot contain a DECNET node name.  The
  877. preprocessor reports an I/O error if you attempt to use a node name,
  878. whether explicitly, or implicitly via a logical name.
  879.  
  880. 
  881. File: gcc.info,  Node: Global Declarations,  Next: VMS Misc,  Prev: Include Files and VMS,  Up: VMS
  882.  
  883. Global Declarations and VMS
  884. ===========================
  885.  
  886.    GNU CC does not provide the `globalref', `globaldef' and
  887. `globalvalue' keywords of VAX-C.  You can get the same effect with an
  888. obscure feature of GAS, the GNU assembler.  (This requires GAS version
  889. 1.39 or later.)  The following macros allow you to use this feature in
  890. a fairly natural way:
  891.  
  892.      #ifdef __GNUC__
  893.      #define GLOBALREF(TYPE,NAME)                      \
  894.        TYPE NAME                                       \
  895.        asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME)
  896.      #define GLOBALDEF(TYPE,NAME,VALUE)                \
  897.        TYPE NAME                                       \
  898.        asm ("_$$PsectAttributes_GLOBALSYMBOL$$" #NAME) \
  899.          = VALUE
  900.      #define GLOBALVALUEREF(TYPE,NAME)                 \
  901.        const TYPE NAME[1]                              \
  902.        asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME)
  903.      #define GLOBALVALUEDEF(TYPE,NAME,VALUE)           \
  904.        const TYPE NAME[1]                              \
  905.        asm ("_$$PsectAttributes_GLOBALVALUE$$" #NAME)  \
  906.          = {VALUE}
  907.      #else
  908.      #define GLOBALREF(TYPE,NAME) \
  909.        globalref TYPE NAME
  910.      #define GLOBALDEF(TYPE,NAME,VALUE) \
  911.        globaldef TYPE NAME = VALUE
  912.      #define GLOBALVALUEDEF(TYPE,NAME,VALUE) \
  913.        globalvalue TYPE NAME = VALUE
  914.      #define GLOBALVALUEREF(TYPE,NAME) \
  915.        globalvalue TYPE NAME
  916.      #endif
  917.  
  918. (The `_$$PsectAttributes_GLOBALSYMBOL' prefix at the start of the name
  919. is removed by the assembler, after it has modified the attributes of
  920. the symbol).  These macros are provided in the VMS binaries
  921. distribution in a header file `GNU_HACKS.H'.  An example of the usage
  922. is:
  923.  
  924.      GLOBALREF (int, ijk);
  925.      GLOBALDEF (int, jkl, 0);
  926.  
  927.    The macros `GLOBALREF' and `GLOBALDEF' cannot be used
  928. straightforwardly for arrays, since there is no way to insert the array
  929. dimension into the declaration at the right place.  However, you can
  930. declare an array with these macros if you first define a typedef for the
  931. array type, like this:
  932.  
  933.      typedef int intvector[10];
  934.      GLOBALREF (intvector, foo);
  935.  
  936.    Array and structure initializers will also break the macros; you can
  937. define the initializer to be a macro of its own, or you can expand the
  938. `GLOBALDEF' macro by hand.  You may find a case where you wish to use
  939. the `GLOBALDEF' macro with a large array, but you are not interested in
  940. explicitly initializing each element of the array.  In such cases you
  941. can use an initializer like: `{0,}', which will initialize the entire
  942. array to `0'.
  943.  
  944.    A shortcoming of this implementation is that a variable declared with
  945. `GLOBALVALUEREF' or `GLOBALVALUEDEF' is always an array.  For example,
  946. the declaration:
  947.  
  948.      GLOBALVALUEREF(int, ijk);
  949.  
  950. declares the variable `ijk' as an array of type `int [1]'.  This is
  951. done because a globalvalue is actually a constant; its "value" is what
  952. the linker would normally consider an address.  That is not how an
  953. integer value works in C, but it is how an array works.  So treating
  954. the symbol as an array name gives consistent results--with the
  955. exception that the value seems to have the wrong type.  *Don't try to
  956. access an element of the array.*  It doesn't have any elements.  The
  957. array "address" may not be the address of actual storage.
  958.  
  959.    The fact that the symbol is an array may lead to warnings where the
  960. variable is used.  Insert type casts to avoid the warnings.  Here is an
  961. example; it takes advantage of the ANSI C feature allowing macros that
  962. expand to use the same name as the macro itself.
  963.  
  964.      GLOBALVALUEREF (int, ss$_normal);
  965.      GLOBALVALUEDEF (int, xyzzy,123);
  966.      #ifdef __GNUC__
  967.      #define ss$_normal ((int) ss$_normal)
  968.      #define xyzzy ((int) xyzzy)
  969.      #endif
  970.  
  971.    Don't use `globaldef' or `globalref' with a variable whose type is
  972. an enumeration type; this is not implemented.  Instead, make the
  973. variable an integer, and use a `globalvaluedef' for each of the
  974. enumeration values.  An example of this would be:
  975.  
  976.      #ifdef __GNUC__
  977.      GLOBALDEF (int, color, 0);
  978.      GLOBALVALUEDEF (int, RED, 0);
  979.      GLOBALVALUEDEF (int, BLUE, 1);
  980.      GLOBALVALUEDEF (int, GREEN, 3);
  981.      #else
  982.      enum globaldef color {RED, BLUE, GREEN = 3};
  983.      #endif
  984.  
  985. 
  986. File: gcc.info,  Node: VMS Misc,  Prev: Global Declarations,  Up: VMS
  987.  
  988. Other VMS Issues
  989. ================
  990.  
  991.    GNU CC automatically arranges for `main' to return 1 by default if
  992. you fail to specify an explicit return value.  This will be interpreted
  993. by VMS as a status code indicating a normal successful completion.
  994. Version 1 of GNU CC did not provide this default.
  995.  
  996.    GNU CC on VMS works only with the GNU assembler, GAS.  You need
  997. version 1.37 or later of GAS in order to produce value debugging
  998. information for the VMS debugger.  Use the ordinary VMS linker with the
  999. object files produced by GAS.
  1000.  
  1001.    Under previous versions of GNU CC, the generated code would
  1002. occasionally give strange results when linked to the sharable `VAXCRTL'
  1003. library.  Now this should work.
  1004.  
  1005.    A caveat for use of `const' global variables: the `const' modifier
  1006. must be specified in every external declaration of the variable in all
  1007. of the source files that use that variable.  Otherwise the linker will
  1008. issue warnings about conflicting attributes for the variable.  Your
  1009. program will still work despite the warnings, but the variable will be
  1010. placed in writable storage.
  1011.  
  1012.    Although the VMS linker does distinguish between upper and lower case
  1013. letters in global symbols, most VMS compilers convert all such symbols
  1014. into upper case and most run-time library routines also have upper case
  1015. names.  To be able to reliably call such routines, GNU CC (by means of
  1016. the assembler GAS) converts global symbols into upper case like other
  1017. VMS compilers.  However, since the usual practice in C is to distinguish
  1018. case, GNU CC (via GAS) tries to preserve usual C behavior by augmenting
  1019. each name that is not all lower case.  This means truncating the name
  1020. to at most 23 characters and then adding more characters at the end
  1021. which encode the case pattern of those 23.   Names which contain at
  1022. least one dollar sign are an exception; they are converted directly into
  1023. upper case without augmentation.
  1024.  
  1025.    Name augmentation yields bad results for programs that use
  1026. precompiled libraries (such as Xlib) which were generated by another
  1027. compiler.  You can use the compiler option `/NOCASE_HACK' to inhibit
  1028. augmentation; it makes external C functions and variables
  1029. case-independent as is usual on VMS.  Alternatively, you could write
  1030. all references to the functions and variables in such libraries using
  1031. lower case; this will work on VMS, but is not portable to other
  1032. systems.  The compiler option `/NAMES' also provides control over
  1033. global name handling.
  1034.  
  1035.    Function and variable names are handled somewhat differently with GNU
  1036. C++.  The GNU C++ compiler performs "name mangling" on function names,
  1037. which means that it adds information to the function name to describe
  1038. the data types of the arguments that the function takes.  One result of
  1039. this is that the name of a function can become very long.  Since the
  1040. VMS linker only recognizes the first 31 characters in a name, special
  1041. action is taken to ensure that each function and variable has a unique
  1042. name that can be represented in 31 characters.
  1043.  
  1044.    If the name (plus a name augmentation, if required) is less than 32
  1045. characters in length, then no special action is performed.  If the name
  1046. is longer than 31 characters, the assembler (GAS) will generate a hash
  1047. string based upon the function name, truncate the function name to 23
  1048. characters, and append the hash string to the truncated name.  If the
  1049. `/VERBOSE' compiler option is used, the assembler will print both the
  1050. full and truncated names of each symbol that is truncated.
  1051.  
  1052.    The `/NOCASE_HACK' compiler option should not be used when you are
  1053. compiling programs that use libg++.  libg++ has several instances of
  1054. objects (i.e.  `Filebuf' and `filebuf') which become indistinguishable
  1055. in a case-insensitive environment.  This leads to cases where you need
  1056. to inhibit augmentation selectively (if you were using libg++ and Xlib
  1057. in the same program, for example).  There is no special feature for
  1058. doing this, but you can get the result by defining a macro for each
  1059. mixed case symbol for which you wish to inhibit augmentation.  The
  1060. macro should expand into the lower case equivalent of itself.  For
  1061. example:
  1062.  
  1063.      #define StuDlyCapS studlycaps
  1064.  
  1065.    These macro definitions can be placed in a header file to minimize
  1066. the number of changes to your source code.
  1067.  
  1068. 
  1069. File: gcc.info,  Node: Portability,  Next: Interface,  Prev: VMS,  Up: Top
  1070.  
  1071. GNU CC and Portability
  1072. **********************
  1073.  
  1074.    The main goal of GNU CC was to make a good, fast compiler for
  1075. machines in the class that the GNU system aims to run on: 32-bit
  1076. machines that address 8-bit bytes and have several general registers.
  1077. Elegance, theoretical power and simplicity are only secondary.
  1078.  
  1079.    GNU CC gets most of the information about the target machine from a
  1080. machine description which gives an algebraic formula for each of the
  1081. machine's instructions.  This is a very clean way to describe the
  1082. target.  But when the compiler needs information that is difficult to
  1083. express in this fashion, I have not hesitated to define an ad-hoc
  1084. parameter to the machine description.  The purpose of portability is to
  1085. reduce the total work needed on the compiler; it was not of interest
  1086. for its own sake.
  1087.  
  1088.    GNU CC does not contain machine dependent code, but it does contain
  1089. code that depends on machine parameters such as endianness (whether the
  1090. most significant byte has the highest or lowest address of the bytes in
  1091. a word) and the availability of autoincrement addressing.  In the
  1092. RTL-generation pass, it is often necessary to have multiple strategies
  1093. for generating code for a particular kind of syntax tree, strategies
  1094. that are usable for different combinations of parameters.  Often I have
  1095. not tried to address all possible cases, but only the common ones or
  1096. only the ones that I have encountered.  As a result, a new target may
  1097. require additional strategies.  You will know if this happens because
  1098. the compiler will call `abort'.  Fortunately, the new strategies can be
  1099. added in a machine-independent fashion, and will affect only the target
  1100. machines that need them.
  1101.  
  1102.